/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Modelo.DAL;

import Modelo.NovedadGenerica;
import Modelo.NovedadEspecifica;
import Modelo.CampoNovedad;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.json.JSONObject;
import java.util.List;
import org.json.JSONArray;

/**
 *
 * @author miguel474
 */
public class Novedad_DAO {

    //Agrega una Novedad Genérica, devuelve su clave primaria
    public static int agregarNovedadGenerica(NovedadGenerica gen, List<CampoNovedad> campos_novedad) {
        ConexionBD conexion = new ConexionBD();
        PreparedStatement s = null;
        int novedad_generica = -1;
        String query = "BEGIN; INSERT INTO novedad_generica(nombre_novedad_gen,"
                + " descripcion, intervalo_alerta,ocurrencias, estado)"
                + "VALUES (?, ?, ?,?, ?)";

        try {
            s = conexion.session.prepareStatement(query);
            s.setString(1, gen.getNombre_novedad_gen());
            s.setString(2, gen.getDescripcion());
            s.setInt(3, gen.getIntervalo_alerta());
            s.setInt(4, gen.getOcurrencias());
            s.setBoolean(5, true);
            s.executeUpdate();
        } catch (SQLException se) {
            System.out.println("Error Agregando Novedad Genérica");
            return rollbackInsert(conexion, s);
        }
        query = "SELECT MAX(id_novedad_gen) from novedad_generica";
        try {
            s = conexion.session.prepareStatement(query);
            ResultSet rs = s.executeQuery();
            if (!rs.next()) {
                System.out.println("Error Obteniendo el ID de la última novedad!\n");
                return rollbackInsert(conexion, s);
            }
            novedad_generica = rs.getInt(1);
            System.out.println("Novedad Genérica: " + novedad_generica + ".\n");
            rs.close();
        } catch (SQLException se) {
            System.out.println("Error Obteniendo el ID de la última novedad!\n");
            return rollbackInsert(conexion, s);
        }
        //Novedad Específica Nueva
        query = "INSERT INTO novedad_especifica(id_novedad_gen,"
                + "nombre_novedad_esp, descripcion, intervalo_alerta,"
                + "ocurrencias, estado)VALUES (?, ?, ?, ?, ?, ?)";

        try {
            s = conexion.session.prepareStatement(query);
            s.setInt(1, novedad_generica);
            s.setString(2, gen.getNombre_novedad_gen());
            s.setString(3, gen.getDescripcion());
            s.setInt(4, gen.getIntervalo_alerta());
            s.setInt(5, gen.getOcurrencias());
            s.setBoolean(6, true);
            s.executeUpdate();
        } catch (SQLException se) {
            System.out.println("Error Agregando Novedad Específica");
            return rollbackInsert(conexion, s);
        }

        for (int i = 0; campos_novedad.size() > i; i++) {
            query = "INSERT INTO campo_novedad_generica(id_novedad_generica, nombre, longitud, metodo_validacion, obligatorio)"
                    + "VALUES (?, ?, ?, ?, ?)";
            try {
                s = conexion.session.prepareStatement(query);
                s.setInt(1, novedad_generica);
                s.setString(2, campos_novedad.get(i).getNombre_campo());
                s.setInt(3, Integer.parseInt(campos_novedad.get(i).getLogitud()));
                s.setInt(4, Integer.parseInt(campos_novedad.get(i).getValidacion_campo()));
                s.setBoolean(5, Boolean.getBoolean(campos_novedad.get(i).getObligatorio_campo()));
                s.executeUpdate();
                System.out.println("Asociado Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Generica:" + novedad_generica);
            } catch (SQLException se) {
                System.out.println("Error asociando Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Generica:" + novedad_generica);
                return rollbackInsert(conexion, s);
            }
        }
        try {
            s = conexion.session.prepareStatement("COMMIT;");
            s.executeUpdate();
            System.out.println("Novedade Genérica " + novedad_generica + " Agregado Exitosamente!\n");
            return novedad_generica;
        } catch (SQLException ex) {
            System.out.println("Novedade Genérica " + novedad_generica + " no pudo ser agregada!\n");
            return rollbackInsert(conexion, s);
        }
    }

    public static int actualizarNovedadGenerica(NovedadGenerica gen, List<CampoNovedad> campos_novedad) {
        ConexionBD conexion = new ConexionBD();
        String query = "BEGIN;UPDATE novedad_generica SET descripcion=?, intervalo_alerta=?, ocurrencias=? WHERE id_novedad_gen=?";
        PreparedStatement s = null;
        try {
            s = conexion.session.prepareStatement(query);
            s.setString(1, gen.getDescripcion());
            s.setInt(2, gen.getIntervalo_alerta());
            s.setInt(3, gen.getOcurrencias());
            s.setInt(4, gen.getId_novedad_gen());
            s.executeUpdate();
        } catch (SQLException se) {
            System.out.println("Error Actualizando Novedad Genérica");
            return rollbackInsert(conexion, s);
        }

        query = "DELETE FROM campo_novedad_generica WHERE id_novedad_generica = ?";
        try {
            s = conexion.session.prepareStatement(query);
            s.setInt(1, gen.getId_novedad_gen());
            s.executeUpdate();
        } catch (SQLException ex) {
            System.out.println("Error Eliminando Campos Novedad Genérica");
            return rollbackInsert(conexion, s);
        }

        for (int i = 0; campos_novedad.size() > i; i++) {
            query = "INSERT INTO campo_novedad_generica(id_novedad_generica, nombre, longitud, metodo_validacion, obligatorio)"
                    + "VALUES (?, ?, ?, ?, ?)";
            try {
                s = conexion.session.prepareStatement(query);
                s.setInt(1, gen.getId_novedad_gen());
                s.setString(2, campos_novedad.get(i).getNombre_campo());
                s.setInt(3, Integer.parseInt(campos_novedad.get(i).getLogitud()));
                s.setInt(4, Integer.parseInt(campos_novedad.get(i).getValidacion_campo()));
                System.out.println("EN DAO:" + campos_novedad.get(i).getObligatorio_campo());
                if (campos_novedad.get(i).getObligatorio_campo().equals("true")) {
                    s.setBoolean(5, true);
                } else {
                    s.setBoolean(5, false);
                }
                s.executeUpdate();
                System.out.println("Asociado Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Generica:" + gen.getId_novedad_gen());
            } catch (SQLException se) {
                System.out.println("Error asociando Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Generica:" + gen.getId_novedad_gen());
                return rollbackInsert(conexion, s);
            }
        }
        try {
            s = conexion.session.prepareStatement("COMMIT;");
            s.executeUpdate();
            System.out.println("Novedade Genérica " + gen.getId_novedad_gen() + " Modificada Exitosamente!\n");
            return gen.getId_novedad_gen();
        } catch (SQLException ex) {
            System.out.println("Novedade Genérica " + gen.getId_novedad_gen() + " no pudo ser modificada!\n");
            return rollbackInsert(conexion, s);
        }
    }

    private static int rollbackInsert(ConexionBD conexion, PreparedStatement s) {
        try {
            System.out.println("Error Insertando Novedad!");
            s = conexion.session.prepareStatement("ROLLBACK;");
            s.executeUpdate();
            conexion.cerrarConexion();
        } catch (SQLException ex) {
            System.out.println("Error en Transaccion! " + ex.getMessage());
        }
        return -1;
    }

    public static int agregarNovedadEspecifica(NovedadEspecifica esp, List<CampoNovedad> campos_novedad) {
        ConexionBD conexion = new ConexionBD();
        PreparedStatement s = null;
        int novedad_especifica = -1;
        String query = "BEGIN; INSERT INTO novedad_especifica(id_novedad_gen,"
                + "nombre_novedad_esp, descripcion, intervalo_alerta,"
                + "ocurrencias, estado)VALUES (?, ?, ?, ?, ?, ?)";

        try {
            s = conexion.session.prepareStatement(query);
            s.setInt(1, esp.getId_novedad_gen());
            s.setString(2, esp.getNombre_novedad_esp());
            s.setString(3, esp.getDescripcion());
            s.setInt(4, esp.getIntervalo_alerta());
            s.setInt(5, esp.getOcurrencias());
            s.setBoolean(6, true);
            s.executeUpdate();
        } catch (SQLException se) {
            System.out.println("Error Agregando Novedad Específica "+ se.getMessage());
            return rollbackInsert(conexion, s);
        }

        query = "SELECT MAX(id_novedad_esp) from novedad_especifica";
        try {
            s = conexion.session.prepareStatement(query);
            ResultSet rs = s.executeQuery();
            if (!rs.next()) {
                System.out.println("Error Obteniendo el ID de la última Novedad Específica!\n");
                return rollbackInsert(conexion, s);
            }
            novedad_especifica = rs.getInt(1);
            System.out.println("ID Novedad Espeifica: " + novedad_especifica + ".\n");
            rs.close();
        } catch (SQLException se) {
            System.out.println("Error obteniendo ultimo ID de la Novedad!\n");
            return rollbackInsert(conexion, s);
        }

        for (int i = 0; campos_novedad.size() > i; i++) {
            query = "INSERT INTO campo_novedad_especifica(id_novedad_especifica, nombre, longitud, metodo_validacion, obligatorio)VALUES (?, ?, ?, ?, ?)";
            try {
                s = conexion.session.prepareStatement(query);
                s.setInt(1, novedad_especifica);
                s.setString(2, campos_novedad.get(i).getNombre_campo());
                s.setInt(3, Integer.parseInt(campos_novedad.get(i).getLogitud()));
                s.setInt(4, Integer.parseInt(campos_novedad.get(i).getValidacion_campo()));
                s.setBoolean(5, Boolean.getBoolean(campos_novedad.get(i).getObligatorio_campo()));
                s.executeUpdate();
                System.out.println("Asociado Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Especifica:" + novedad_especifica);
            } catch (SQLException se) {
                System.out.println("Error asociando Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Específica:" + novedad_especifica);
                return rollbackInsert(conexion, s);
            }
        }
        try {
            s = conexion.session.prepareStatement("COMMIT;");
            s.executeUpdate();
            System.out.println("Novedade Especifica " + novedad_especifica + " Agregado Exitosamente!\n");
            return novedad_especifica;
        } catch (SQLException ex) {
            System.out.println("Novedade Especifica " + novedad_especifica + " no pudo ser agregada!\n");
            return rollbackInsert(conexion, s);
        }
    }

    public static int actualizarNovedadEspecifica(NovedadEspecifica esp, List<CampoNovedad> campos_novedad) {
        ConexionBD conexion = new ConexionBD();
        String query = "BEGIN;UPDATE novedad_especifica SET "
                + "descripcion=?, intervalo_alerta=?, ocurrencias=? WHERE"
                + " id_novedad_esp=? AND id_novedad_gen=?";

        PreparedStatement s = null;
        try {
            s = conexion.session.prepareStatement(query);
            System.out.println("1: " + esp.getDescripcion() + " 2:" + esp.getIntervalo_alerta() + " 3:" + esp.getOcurrencias() + " 4:" + esp.getId_novedad_esp() + " 5:" + esp.getId_novedad_gen());
            s.setString(1, esp.getDescripcion());
            s.setInt(2, esp.getIntervalo_alerta());
            s.setInt(3, esp.getOcurrencias());
            s.setInt(4, esp.getId_novedad_esp());
            s.setInt(5, esp.getId_novedad_gen());
            s.executeUpdate();
        } catch (SQLException se) {
            System.out.println("Error Actualizando Novedad Específica "+ se.getMessage());
            return rollbackInsert(conexion, s);
        }

        query = "DELETE FROM campo_novedad_especifica WHERE id_novedad_especifica = ?";
        try {
            s = conexion.session.prepareStatement(query);
            s.setInt(1, esp.getId_novedad_esp());
            s.executeUpdate();
        } catch (SQLException ex) {
            System.out.println("Error Eliminando Campos Novedad Especifica");
            return rollbackInsert(conexion, s);
        }

        for (int i = 0; campos_novedad.size() > i; i++) {
            query = "INSERT INTO campo_novedad_especifica(id_novedad_especifica, nombre, longitud, metodo_validacion, obligatorio)VALUES (?, ?, ?, ?, ?)";
            try {
                s = conexion.session.prepareStatement(query);
                s.setInt(1, esp.getId_novedad_esp());
                s.setString(2, campos_novedad.get(i).getNombre_campo());
                s.setInt(3, Integer.parseInt(campos_novedad.get(i).getLogitud()));
                s.setInt(4, Integer.parseInt(campos_novedad.get(i).getValidacion_campo()));
                System.out.println("EN DAO:" + campos_novedad.get(i).getObligatorio_campo());
                if (campos_novedad.get(i).getObligatorio_campo().equals("true")) {
                    s.setBoolean(5, true);
                } else {
                    s.setBoolean(5, false);
                }
                s.executeUpdate();
                System.out.println("Asociado Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Especifica:" + esp.getId_novedad_esp());
            } catch (SQLException se) {
                System.out.println("Error asociando Campo " + i + ", Nombre: " + campos_novedad.get(i).getNombre_campo() + " a la Novedad Especifica:" + esp.getId_novedad_esp());
                return rollbackInsert(conexion, s);
            }
        }
        try {
            s = conexion.session.prepareStatement("COMMIT;");
            s.executeUpdate();
            System.out.println("Novedade Especifica " + esp.getId_novedad_gen() + " Modificada Exitosamente!\n");
            return esp.getId_novedad_gen();
        } catch (SQLException ex) {
            System.out.println("Novedade Especifica " + esp.getId_novedad_esp() + " no pudo ser modificada!\n");
            return rollbackInsert(conexion, s);
        }
    }

    public static JSONObject obtenerNovedadGenerica(int id_gen) {
        ConexionBD conexion = new ConexionBD();
        PreparedStatement s = null;
        String query = "SELECT nombre_novedad_gen, descripcion, intervalo_alerta,"
                + " ocurrencias FROM novedad_generica WHERE id_novedad_gen = ?;";

        try {
            s = conexion.session.prepareStatement(query);
            s.setInt(1, id_gen);
            ResultSet rs = s.executeQuery();
            /* if (!rs.next()) {
            System.out.println("Error Obteniendo Novedad Generica con Id:" + id_gen);
            return null;
            }*/
            JSONObject novedad_gen = new JSONObject();
            int i = 0;
            while (rs.next()) {
                novedad_gen.put("nombre_novedad_gen", rs.getString(1));
                novedad_gen.put("descripcion", rs.getString(2));
                novedad_gen.put("intervalo_alerta", rs.getInt(3));
                novedad_gen.put("ocurrencias", rs.getInt(4));
            }
            System.out.println("Generica Retornada!");
            return novedad_gen;
        } catch (SQLException se) {
            System.out.println("Error Obteniendo Novedad Generica con Id:" + id_gen);
            return null;
        }
    }

    public static JSONObject obtenerNovedadEspecifica(int id_gen, int id_esp) {
        ConexionBD conexion = new ConexionBD();
        PreparedStatement s = null;
        String query = "SELECT nombre_novedad_esp, esp.descripcion,"
                + "esp.intervalo_alerta, esp.ocurrencias, nombre_novedad_gen FROM novedad_especifica esp ,novedad_generica gen WHERE"
                + " id_novedad_esp = ? AND esp.id_novedad_gen = ? AND esp.id_novedad_gen = gen.id_novedad_gen";

        try {
            s = conexion.session.prepareStatement(query);
            s.setInt(1, id_esp);
            s.setInt(2, id_gen);
            ResultSet rs = s.executeQuery();
            /*if (!rs.next()) {
            System.out.println("Error Obteniendo Novedad Especifica con Id:(" + id_gen + "," + id_esp + ")");
            return null;
            }*/
            JSONObject novedad_gen = new JSONObject();
            int i = 0;
            while (rs.next()) {

                novedad_gen.put("nombre_novedad_esp", rs.getString(1));
                novedad_gen.put("descripcion", rs.getString(2));
                novedad_gen.put("intervalo_alerta", rs.getInt(3));
                novedad_gen.put("ocurrencias", rs.getInt(4));
                novedad_gen.put("nombre_novedad_gen", rs.getString(5));
            }
            return novedad_gen;
        } catch (SQLException se) {
            System.out.println("Error Obteniendo Novedad Especifica con Id:(" + id_gen + "," + id_esp + ")" + se.getMessage());
            return null;
        }
    }

    //Dado el nombre de una novedad genérica, obtiene su id
    public static int getNovedadGenId(String nombre) {
        ConexionBD conexion = new ConexionBD();
        Statement s = null;
        try {
            s = conexion.session.createStatement();
        } catch (SQLException se) {
            System.out.println("Error Insertando Novedad!");
            return -1;
        }
        String query = "select id_novedad_gen from novedad_generica where nombre_novedad_gen = '" + nombre + "'";
        System.out.println("\n\tQuery: " + query + "\n");
        System.out.println(query);
        try {
            ResultSet rs = s.executeQuery(query);
            int clave = -1;
            while (rs.next()) {
                clave = rs.getInt(1);
            }
            conexion.cerrarConexion();
            return clave;
        } catch (SQLException se) {
            System.out.println("Error en la consulta");
            conexion.cerrarConexion();
            return -1;
        }
    }

    public static String getNovedadGenName(String id) {
        ConexionBD conexion = new ConexionBD();
        Statement s = null;
        try {
            s = conexion.session.createStatement();
        } catch (SQLException se) {
            System.out.println("Error Insertando Novedad!");
            return null;
        }
        String query = "select nombre_novedad_gen from novedad_generica where id_novedad_gen = '" + id + "'";
        System.out.println("\n\tQuery: " + query + "\n");
        System.out.println(query);
        try {
            ResultSet rs = s.executeQuery(query);
            String nombre = "";
            while (rs.next()) {
                nombre = rs.getString(1);
            }
            conexion.cerrarConexion();
            return nombre;
        } catch (SQLException se) {
            System.out.println("Error en la consulta");
            conexion.cerrarConexion();
            return null;
        }
    }

    //Dado el nombre de una novedad específica, obtiene su id
    public static int getNovedadEspId(String nombre) {
        ConexionBD conexion = new ConexionBD();
        Statement s = null;
        try {
            s = conexion.session.createStatement();
        } catch (SQLException se) {
            System.out.println("Error Insertando Novedad!");
            return -1;
        }
        String query = "select id_novedad_esp from novedad_especifica where nombre_novedad_esp = '" + nombre + "'";
        System.out.println("\n\tQuery: " + query + "\n");
        System.out.println(query);
        try {
            ResultSet rs = s.executeQuery(query);
            int clave = -1;
            while (rs.next()) {
                clave = rs.getInt(1);
            }
            conexion.cerrarConexion();
            return clave;
        } catch (SQLException se) {
            System.out.println("Error en la consulta");
            conexion.cerrarConexion();
            return -1;
        }
    }

    /**
    public List<String> consultarNombresNovedadGenerica() {
    ConexionBD conexion = new ConexionBD();
    Statement s = null;
    ResultSet rs = null;
    try {
    s = conexion.session.createStatement();
    } catch (SQLException se) {
    System.out.println("Error Consultando un Sede!");
    return null;
    }
    String query = "select nombre_novedad_gen from novedad_generica";
    System.out.println("\n\tQuery: " + query + "\n");
    System.out.println(query);
    listaNombres = new ArrayList<String>();
    try {
    rs = s.executeQuery(query);
    
    
    /*
    Se recorre cada fila del ResultSet para instancia a cada empleado y agregarlo a la lista de empleados.
    /
    while (rs.next()) {
    /* Se instancia del nuevo pre-reporte. *
    String temp = rs.getString("nombre_novedad_gen");
    //PreReporteFetch temp = new PreReporteFetch(
    /* Se agrega el pre-reporte a la lista. *
    listaNombres.add(temp);
    }
    } catch (SQLException se) {
    se.printStackTrace();
    System.out.println("Error Consultado el extintor");
    return null;
    } finally {
    conexion.cerrarConexion();
    }
    //return listaSedes.toArray(new Sede[listaSedes.size()]);
    return listaNombres;
    }
     **/
    //Modulo 2
    public JSONArray listNovedadesGenericas() {
        ConexionBD conexion = new ConexionBD();
        if (conexion.session == null) {
            return null;
        }
        Statement s = null;
        try {
            s = conexion.session.createStatement();
            String query = "SELECT id_novedad_gen, nombre_novedad_gen FROM NOVEDAD_GENERICA";
            ResultSet rs = s.executeQuery(query);
            conexion.session.setHoldability(rs.HOLD_CURSORS_OVER_COMMIT);

            JSONArray tipoN = new JSONArray();
            int i = 0;
            while (rs.next()) {
                JSONObject jo2 = new JSONObject();
                jo2.put("idNovedad", rs.getString(1));
                jo2.put("novedad", rs.getString(2));

                tipoN.put(i++, jo2);
            }
            rs.close();
            return tipoN;
        } catch (SQLException se) {
            System.out.println("Error Consultando Novedades Genericas!\n");
            return null;
        } finally {
            if (conexion != null) {
                conexion.cerrarConexion();
            }
        }
    }

    public JSONArray listarTodasEspecificas() {
        ConexionBD conexion = new ConexionBD();
        if (conexion.session == null) {
            return null;
        }
        Statement s = null;
        try {
            s = conexion.session.createStatement();
            String query = "SELECT id_novedad_esp, nombre_novedad_esp FROM NOVEDAD_ESPECIFICA";
            ResultSet rs = s.executeQuery(query);
            conexion.session.setHoldability(rs.HOLD_CURSORS_OVER_COMMIT);

            JSONArray tipoN = new JSONArray();
            int i = 0;
            while (rs.next()) {
                JSONObject jo2 = new JSONObject();
                jo2.put("idNovedad", rs.getString(1));
                jo2.put("novedad", rs.getString(2));

                tipoN.put(i++, jo2);
            }
            rs.close();
            return tipoN;
        } catch (SQLException se) {
            System.out.println("Error Consultando Novedades Genericas!\n");
            return null;
        } finally {
            if (conexion != null) {
                conexion.cerrarConexion();
            }
        }
    }

    public static JSONArray consultarNovedadEspecifica(String id) {
        ConexionBD conexion = new ConexionBD();
        if (conexion.session == null) {
            return null;
        }
        Statement st = null;

        try {
            st = (Statement) conexion.session.createStatement();
            String query = "SELECT id_novedad_esp, nombre_novedad_esp "
                    + "FROM NOVEDAD_ESPECIFICA "
                    + "WHERE (id_novedad_gen='" + id + "')";

            ResultSet rs = st.executeQuery(query);
            conexion.session.setHoldability(rs.HOLD_CURSORS_OVER_COMMIT);

            JSONArray nombresNovedadesEsp = new JSONArray();
            int i = 0;
            while (rs.next()) {
                JSONObject jo2 = new JSONObject();
                jo2.put("idNovedadEsp", rs.getString(1));
                jo2.put("novedadEsp", rs.getString(2));

                nombresNovedadesEsp.put(i++, jo2);
            }
            rs.close();
            return nombresNovedadesEsp;
        } catch (SQLException se) {
            System.out.println("Error Consultando Novedades Especificas!\n" + se.getMessage());
            return null;
        } finally {
            if (conexion != null) {
                conexion.cerrarConexion();
            }
        }
    }

    public static JSONObject consultarNovedades(String nombre, int id_gen) {
        ConexionBD conexion = new ConexionBD();
        JSONObject nombresNovedades = new JSONObject();
        String query = "";
        int i = 0;
        if (id_gen == -1) {
            try {
                query = "SELECT * FROM novedad_generica where nombre_novedad_gen = ?";
                PreparedStatement s = conexion.session.prepareStatement(query);
                s.setString(1, nombre);
                JSONObject nombreNovedad;
                ResultSet rs = s.executeQuery();
                while (rs.next()) {
                    nombreNovedad = new JSONObject();
                    nombreNovedad.put("nombre_novedad", rs.getString(1));
                    nombresNovedades.put("" + i++, nombreNovedad);
                }
            } catch (Exception e) {
                System.out.println("Error consultando novedades genérica con el nombre:" + nombre);
            } finally {
                conexion.cerrarConexion();
            }
        } else {
            try {
                query = "SELECT * FROM novedad_especifica where nombre_novedad_esp = ? AND id_novedad_gen = ?";
                PreparedStatement s = conexion.session.prepareStatement(query);
                s.setString(1, nombre);
                s.setInt(2, id_gen);
                JSONObject nombreNovedad;
                ResultSet rs = s.executeQuery();
                while (rs.next()) {
                    nombreNovedad = new JSONObject();
                    nombreNovedad.put("nombre_novedad", rs.getString(1));
                    nombresNovedades.put("" + i++, nombreNovedad);
                }
            } catch (Exception e) {
                System.out.println("Error consultando novedades especificas con el nombre:" + nombre + " e ID_Gen:" + id_gen);
            } finally {
                conexion.cerrarConexion();
            }
        }

        return nombresNovedades;
    }

    public static JSONObject getNovedadGen(String id) {
        ConexionBD conex = new ConexionBD();
        JSONObject novedades = new JSONObject();

        try {
            Statement st = (Statement) conex.session.createStatement();
            String ngQuery = "select id_novedad_gen, nombre_novedad_gen, descripcion, alerta_cp, alerta_gen from novedad_generica where id_novedad_gen = " + id;
            ResultSet rs = st.executeQuery(ngQuery);
            int i = 0;
            while (rs.next()) {
                JSONObject novedad = new JSONObject();
                novedad.put("id_novedad_gen", rs.getString(1));
                novedad.put("nombre_novedad_gen", rs.getString(2));
                novedad.put("descripcion", rs.getString(3));
                novedad.put("alerta_cp", rs.getString(4));
                novedad.put("alerta_gen", rs.getString(5));
                novedades.put("" + i++, novedad);
            }
        } catch (SQLException se) {
            System.out.println("Error Consultando Novedades Especificas!\n" + se.getMessage());
            return null;
        } finally {
            if (conex != null) {
                conex.cerrarConexion();
            }
        }
        return novedades;
    }

    public JSONArray consultarEspaciosNovedad(String novedad, String agrega, String via) {
        ConexionBD conexion = new ConexionBD();
        if (conexion.session == null) {
            return null;
        }
        Statement s = null;
        try {
            s = conexion.session.createStatement();
            String query = "SELECT o.nombre_espacio, e.coordX, e.coordY, r.agrega, r.via, r.id_novedad_especifica FROM OCURRE_NOVEDAD_ESPACIO o, ESPACIO e, REPORTE_NOVEDAD r where (o.nombre_espacio = e.nombre_espacio) and (o.id_reporte_novedad = r.id_reporte_novedad)";
            if (novedad != "") {
                query = query + " and (r.id_novedad_especifica='" + novedad + "')";
            }
            if (agrega != "") {
                query = query + " and (r.agrega='" + agrega + "')";
            }
            if (via != "") {
                query = query + " and (r.via='" + via + "')";
            }

            ResultSet rs = s.executeQuery(query);

            conexion.session.setHoldability(rs.HOLD_CURSORS_OVER_COMMIT);
            JSONArray novedades = new JSONArray();
            int i = 0;
            while (rs.next()) {
                JSONObject jo2 = new JSONObject();
                jo2.put("espacio", rs.getString(1));
                jo2.put("coordX", rs.getString(2));
                jo2.put("coordY", rs.getString(3));
                jo2.put("agrega", rs.getString(4));
                jo2.put("via", rs.getString(5));
                jo2.put("novedadEspecifica", rs.getString(6));

                novedades.put(i++, jo2);
            }
            rs.close();
            return novedades;
        } catch (SQLException se) {
            System.out.println("Error Consultando Riesgos!\n" + se.getMessage());
            return null;
        } finally {
            if (conexion != null) {
                conexion.cerrarConexion();
            }
        }
    }

    public static JSONObject getNovedadEsp(String id) {
        ConexionBD conex = new ConexionBD();
        JSONObject novedades = new JSONObject();

        try {
            Statement st = (Statement) conex.session.createStatement();
            String ngQuery = "select id_novedad_esp, nombre_novedad_esp, descripcion, alerta_cp, alerta_gen from novedad_especifica where id_novedad_esp = " + id;
            ResultSet rs = st.executeQuery(ngQuery);
            int i = 0;
            while (rs.next()) {
                JSONObject novedad = new JSONObject();
                novedad.put("id_novedad_esp", rs.getString(1));
                novedad.put("nombre_novedad_esp", rs.getString(2));
                novedad.put("descripcion", rs.getString(3));
                novedad.put("alerta_cp", rs.getString(4));
                novedad.put("alerta_gen", rs.getString(5));
                novedades.put("" + i++, novedad);
            }
        } catch (SQLException se) {
            System.out.println("Error Consultando Novedades Especificas!\n" + se.getMessage());
            return null;
        } finally {
            if (conex != null) {
                conex.cerrarConexion();
            }
        }
        return novedades;
    }
    /**
    public static boolean updateNovedadGen(NovedadGenericanovedad) {
    ConexionBD conexion = new ConexionBD();
    Statement s = null;
    try {
    s = conexion.session.createStatement();
    } catch (SQLException se) {
    System.out.println("Error Insertando Novedad!");
    return false;
    }
    String query = "update novedad_generica set nombre_novedad_gen = '" + novedad.getNombreNovedadGen()
    + "', descripcion = '" + novedad.getDescripcion()
    + "', alerta_gen = " + novedad.getAlertaGen().toString()
    + ", alerta_cp = " + novedad.getAlertaCp().toString()
    + "where id_novedad_gen = " + novedad.getNovedadGen().toString();
    System.out.println("\n\tQuery: " + query + "\n");
    System.out.println(query);
    try {
    s.executeUpdate(query);
    conexion.cerrarConexion();
    return true;
    } catch (SQLException se) {
    System.out.println("Error Actualizando tipo de novedad!");
    conexion.cerrarConexion();
    return false;
    }
    }
    
    public static boolean updateNovedadEsp(NovedadEspecifica novedad) {
    ConexionBD conexion = new ConexionBD();
    Statement s = null;
    try {
    s = conexion.session.createStatement();
    } catch (SQLException se) {
    System.out.println("Error Insertando Novedad!");
    return false;
    }
    String query = "update novedad_especifica set nombre_novedad_esp = '" + novedad.getNombreNovedadEsp()
    + "', descripcion = '" + novedad.getDescripcion()
    + "', alerta_gen = " + novedad.getAlertaGen().toString()
    + ", alerta_cp = " + novedad.getAlertaCp().toString()
    + "where id_novedad_esp = " + novedad.getNovedadEsp().toString();
    System.out.println("\n\tQuery: " + query + "\n");
    System.out.println(query);
    try {
    s.executeUpdate(query);
    conexion.cerrarConexion();
    return true;
    } catch (SQLException se) {
    System.out.println("Error Actualizando tipo de novedad!");
    conexion.cerrarConexion();
    return false;
    }
    }
     * */
}
